/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package wasolicitudesfiec.logicacontrol;

import web.util.Constantes;
import entidad.apertura.Solicitudaperturapostgrado;
import entidad.apertura.Solicitudaperturatopico;
import entidad.ayudantias.Solicitudayudantia;
import entidad.ayudantias.Solicitudserayudante;
import entidad.cambioCarrera.Solicitudcambiocarrera;
import entidad.convalidacionMateria.Solicitudconvalidacionmateria;
import java.sql.*;
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import wasolicitudesfiec.consultas.ConexionDBHistorial;
import wasolicitudesfiec.consultas.ConsultasHistorial;
import wasolicitudesfiec.registros.Rg_Solicitud;

/**
 *
 * @author kabad
 */
public class LogicaHistorial {

    ConexionDBHistorial conexionDBHistorial = new ConexionDBHistorial();
    private ConsultasHistorial consultasHistorial = new ConsultasHistorial();
    private Logica logica = new Logica();

    public LogicaHistorial() {
    }

    public Vector<Rg_Solicitud> leerActividadesPorProceso(String nombreInstancia) throws SQLException {
        Vector<Rg_Solicitud> listaActividades = new Vector<Rg_Solicitud>();
        Connection con = null;
        Pattern p = Pattern.compile("\\d");
        Matcher m = p.matcher(nombreInstancia);
        boolean b = false;
        String idTemp = "";
        while (b = m.find()) {
//            System.out.print(m.start() + " "+ " " + m.group());
            idTemp += m.group();
        }
        int idInstancia = Integer.parseInt(idTemp);
        try {
            con = conexionDBHistorial.openConexion();
            consultasHistorial.setConexion(con);
            listaActividades = consultasHistorial.leerNodosPorInstancia(idInstancia);
        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return listaActividades;
    }

    public String leerPropiedadporActividad(int idNodo, String nombrePropiedad) throws SQLException {
        String valorPropiedad = "";
        Connection con = null;
        try {
            con = conexionDBHistorial.openConexion();
            consultasHistorial.setConexion(con);
            valorPropiedad = consultasHistorial.leerPropiedadporNodo(idNodo, nombrePropiedad);
        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return valorPropiedad;
    }

    public String leerPropiedadporProceso(int idProceso, String nombrePropiedad) throws SQLException {
        String valorPropiedad = "";
        Connection con = null;
        try {
            con = conexionDBHistorial.openConexion();
            consultasHistorial.setConexion(con);
            valorPropiedad = consultasHistorial.leerPropiedadporProceso(idProceso, nombrePropiedad);
        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return valorPropiedad;
    }

    public Vector<Rg_Solicitud> leerActividadesSolicitarAyudantes(String nombreInstancia) throws SQLException {
        Vector<Rg_Solicitud> listaActividades = new Vector<Rg_Solicitud>();
        listaActividades = leerActividadesPorProceso(nombreInstancia);
        boolean actividadNoRealizable;
        for (Rg_Solicitud reg : listaActividades) {
            actividadNoRealizable = (Constantes.SolicitarAyudantes.enviarConvocatoria.equals(reg.getActividad()) ||
                    Constantes.SolicitarAyudantes.registroEstudiantes.equals(reg.getActividad())) ||
                    (Constantes.SolicitarAyudantes.enviarNotificacionEstudiantesSeleccionados.equals(reg.getActividad()) ||
                    Constantes.SolicitarAyudantes.esperarConfirmacion.equals(reg.getActividad()));
            String accion = "";
            if (Constantes.SolicitarAyudantes.revisarSolicitud.equals(reg.getActividad())) {
                accion = this.leerPropiedadporActividad(reg.getIdSolicitud(), Constantes.Atributo.decisionRevision);
                accion = "Decisión: " + accion;
            }
            if (Constantes.SolicitarAyudantes.volverASolicitar.equals(reg.getActividad())) {
                accion = this.leerPropiedadporActividad(reg.getIdSolicitud(), Constantes.Atributo.decisionVolverASolicitar);
                accion = "Decisión: " + accion;
            }
            if (Constantes.SolicitarAyudantes.seleccionarAyudantes.equals(reg.getActividad())) {
                accion = this.leerPropiedadporActividad(reg.getIdSolicitud(), Constantes.Atributo.decisionSeleccionAyudantes);
                accion = "Decisión: " + accion;
            }
            if (Constantes.SolicitarAyudantes.revisarResultados.equals(reg.getActividad())) {
                accion = this.leerPropiedadporActividad(reg.getIdSolicitud(), Constantes.Atributo.decisionEvaluacion);
                accion = "Decisión: " + accion;
            }
            String ejecutor = reg.getEjecutor();
            int idnodo = reg.getIdSolicitud();
            int idSolicitud = Integer.parseInt(leerPropiedadporActividad(idnodo, Constantes.Atributo.idSolicitudActividad));
            Solicitudayudantia solicitud = logica.getLogAyudantia().leerSolicitudayudantia(idSolicitud);
            reg.setFechamodificacion(solicitud.getFechamodificacion());
            reg.setNombreinstanciaproceso(nombreInstancia);
            reg.setAccion(accion);
            reg.setModelo(Constantes.Modelo.modelo_SolicitarAyudantes);
            //truco: pongo el id del nodo en estado porque lo voy a necesitar para enviarlo en el url de la actividad
            reg.setEstado(idnodo + "");
            reg.setIdSolicitud(idSolicitud);
            if (actividadNoRealizable || ejecutor.equals("comodin")) {
                reg.setRolEjecutor("Sistema");
                reg.setEjecutor("");
            } else {
                reg.setEjecutor(logica.leerPersonaPorUsuario(ejecutor).toString());
            }

        }
        return listaActividades;

    }

    public Vector<Rg_Solicitud> leerActividadesSolicitarSerAyudantes(String nombreInstancia) throws SQLException {
        Vector<Rg_Solicitud> listaActividades = new Vector<Rg_Solicitud>();
        listaActividades = leerActividadesPorProceso(nombreInstancia);
        for (Rg_Solicitud reg : listaActividades) {
            String accion = "";
            if (Constantes.SolicitarSerAyudante.revisarSolicitud.equals(reg.getActividad())) {
                accion = this.leerPropiedadporActividad(reg.getIdSolicitud(), Constantes.Atributo.decisionRevision);
                accion = "Decisión: " + accion;
            }
            if (Constantes.SolicitarSerAyudante.confirmarAceptacion.equals(reg.getActividad())) {
                accion = this.leerPropiedadporActividad(reg.getIdSolicitud(), Constantes.Atributo.decisionConfirmacion);
                accion = "Decisión: " + accion;
            }
            if (Constantes.SolicitarSerAyudante.prorrogarConfirmacion.equals(reg.getActividad())) {
                accion = this.leerPropiedadporActividad(reg.getIdSolicitud(), Constantes.Atributo.decisionProrrogar);
                accion = "Decisión: " + accion;
            }
            String ejecutor = reg.getEjecutor();
            int idnodo = reg.getIdSolicitud();
            int idSolicitud = Integer.parseInt(leerPropiedadporActividad(idnodo, Constantes.Atributo.idSolicitudActividad));
            Solicitudserayudante solicitud = logica.getLogAyudantia().leerSolicitudserayudanteNivel2(idSolicitud);
            reg.setFechamodificacion(solicitud.getFechamodificacion());
            reg.setNombreinstanciaproceso(nombreInstancia);

            reg.setAccion(accion);
            reg.setModelo(Constantes.Modelo.modelo_SolicitarSerAyudante);
            //truco: pongo el id del nodo en estado porque lo voy a necesitar para enviarlo en el url de la actividad
            reg.setEstado(idnodo + "");
            reg.setIdSolicitud(idSolicitud);
            if (reg.getActividad().equals(Constantes.SolicitarSerAyudante.configurarFechaConfirmacion)) {
                reg.setRolEjecutor("Sistema");
                reg.setEjecutor("");
            } else if (ejecutor.equals("comodin")) {
                reg.setRolEjecutor("Profesor");
                reg.setEjecutor(solicitud.getSolicitudayudantia().getProfesor().getPersona().toString());
            } else {
                reg.setEjecutor(logica.leerPersonaPorUsuario(ejecutor).toString());
            }

        }
        return listaActividades;
    }

    public Vector<Rg_Solicitud> leerActividadesSolicitarCambio(String nombreInstancia) throws SQLException {
        Vector<Rg_Solicitud> listaActividades = new Vector<Rg_Solicitud>();
        listaActividades = leerActividadesPorProceso(nombreInstancia);
        for (Rg_Solicitud reg : listaActividades) {

            String ejecutor = reg.getEjecutor();
            int idnodo = reg.getIdSolicitud();
            int idSolicitud = Integer.parseInt(leerPropiedadporActividad(idnodo, Constantes.Atributo.idSolicitudActividad));
            Solicitudcambiocarrera solicitud = logica.getLogCambioCarrera().leerSolicitudCambio(idSolicitud);
            reg.setFechamodificacion(solicitud.getFechamodificacion());
            reg.setNombreinstanciaproceso(nombreInstancia);
            String accion = "";
            if (Constantes.SolicitarCambio.revisarSolicitud.equals(reg.getActividad())) {
                accion = this.leerPropiedadporActividad(reg.getIdSolicitud(), Constantes.Atributo.decisionRevision);
                accion = "Decisión: " + accion;
            }
            if (Constantes.SolicitarCambio.volverASolicitar.equals(reg.getActividad())) {
                accion = this.leerPropiedadporActividad(reg.getIdSolicitud(), Constantes.Atributo.decisionVolverASolicitar);
                accion = "Decisión: " + accion;
            }
            if (Constantes.SolicitarCambio.revisarInforme.equals(reg.getActividad())) {
                accion = this.leerPropiedadporActividad(reg.getIdSolicitud(), Constantes.Atributo.decisionEvaluacion);
                accion = "Decisión: " + accion;
            }
            if (Constantes.SolicitarCambio.emitirInforme.equals(reg.getActividad())) {
                accion = "Informe: " + this.leerPropiedadporActividad(reg.getIdSolicitud(), Constantes.Atributo.informe);
            }
            reg.setAccion(accion);
            reg.setModelo(Constantes.Modelo.modelo_SolicitarCambioCarrera);
            //truco: pongo el id del nodo en estado porque lo voy a necesitar para enviarlo en el url de la actividad 
            reg.setEstado(idnodo + "");
            reg.setIdSolicitud(idSolicitud);
            reg.setEjecutor(logica.leerPersonaPorUsuario(ejecutor).toString());

        }
        return listaActividades;
    }

    public Vector<Rg_Solicitud> leerActividadesSolicitarConvalidacion(String nombreInstancia) throws SQLException {

        Vector<Rg_Solicitud> listaActividades = new Vector<Rg_Solicitud>();
        listaActividades = leerActividadesPorProceso(nombreInstancia);
        for (Rg_Solicitud reg : listaActividades) {

            String ejecutor = reg.getEjecutor();
            int idnodo = reg.getIdSolicitud();
            int idSolicitud = Integer.parseInt(leerPropiedadporActividad(idnodo, Constantes.Atributo.idSolicitudActividad));
            Solicitudconvalidacionmateria solicitud = logica.getLogConvalidacionMateria().leerSolicitudConvalidacion(idSolicitud);
            reg.setFechamodificacion(solicitud.getFechamodificacion());
            reg.setNombreinstanciaproceso(nombreInstancia);
            String accion = "";
            if (Constantes.SolicitarConvalidacion.revisarSolicitud.equals(reg.getActividad())) {
                accion = this.leerPropiedadporActividad(reg.getIdSolicitud(), Constantes.Atributo.decisionRevision);
                accion = "Decisión: " + accion;
            }
            if (Constantes.SolicitarConvalidacion.volverASolicitar.equals(reg.getActividad())) {
                accion = this.leerPropiedadporActividad(reg.getIdSolicitud(), Constantes.Atributo.decisionVolverASolicitar);
                accion = "Decisión: " + accion;
            }
            if (Constantes.SolicitarConvalidacion.revisarInforme.equals(reg.getActividad())) {
                accion = this.leerPropiedadporActividad(reg.getIdSolicitud(), Constantes.Atributo.decisionEvaluacion);
                accion = "Decisión: " + accion;
            }
            if (Constantes.SolicitarConvalidacion.emitirInforme.equals(reg.getActividad())) {
                accion = "Informe: " + this.leerPropiedadporActividad(reg.getIdSolicitud(), Constantes.Atributo.informe);
            }
            reg.setAccion(accion);
            reg.setModelo(Constantes.Modelo.modelo_SolicitarConvalidacionMateria);
            //truco: pongo el id del nodo en estado porque lo voy a necesitar para enviarlo en el url de la actividad 
            reg.setEstado(idnodo + "");
            reg.setIdSolicitud(idSolicitud);
            reg.setEjecutor(logica.leerPersonaPorUsuario(ejecutor).toString());
        }
        return listaActividades;
    }

    public Vector<Rg_Solicitud> leerActividadesSolicitarAperturaTopico(String nombreInstancia) throws SQLException {

        Vector<Rg_Solicitud> listaActividades = new Vector<Rg_Solicitud>();
        listaActividades = leerActividadesPorProceso(nombreInstancia);
        for (int i = 0; i < listaActividades.size(); i++) {
            Rg_Solicitud reg = listaActividades.get(i);
            String ejecutor = reg.getEjecutor();
            if (!ejecutor.equals("comodin")) {
                int idnodo = reg.getIdSolicitud();
                int idSolicitud = Integer.parseInt(leerPropiedadporActividad(idnodo, Constantes.Atributo.idSolicitudActividad));
                Solicitudaperturatopico solicitud = logica.getLogAperturaTopico().leerSolicitudApertura(idSolicitud);
                reg.setFechamodificacion(solicitud.getFechamodificacion());
                reg.setNombreinstanciaproceso(nombreInstancia);
                String accion = "";

                if ((solicitud.getFkIdEvaluador1() != 0) && Constantes.SolicitarAperturaTopico.emitirInformeEvaluador1.equals(reg.getActividad())) {
                    accion = "Resultado: " + solicitud.getInforme1();
                }
                if ((solicitud.getFkIdEvaluador2() != 0) && Constantes.SolicitarAperturaTopico.emitirInformeEvaluador2.equals(reg.getActividad())) {
                    accion = "Resultado: " + solicitud.getInforme2();
                }
                if ((solicitud.getFkIdEvaluador3() != 0) && Constantes.SolicitarAperturaTopico.emitirInformeEvaluador3.equals(reg.getActividad())) {
                    accion = "Resultado: " + solicitud.getInforme3();
                }
                reg.setAccion(accion);
                //truco: pongo el id del nodo en estado porque lo voy a necesitar para enviarlo en el url de la actividad 
                reg.setEstado(idnodo + "");
                reg.setIdSolicitud(idSolicitud);
                reg.setEjecutor(logica.leerPersonaPorUsuario(ejecutor).toString());
            } else {
                listaActividades.remove(i);
                i--;
            }
        }
        return listaActividades;
    }

    public Vector<Rg_Solicitud> leerActividadesSolicitarAperturaPostgrado(String nombreInstancia) throws SQLException {

        Vector<Rg_Solicitud> listaActividades = new Vector<Rg_Solicitud>();
        listaActividades = leerActividadesPorProceso(nombreInstancia);
        for (int i = 0; i < listaActividades.size(); i++) {
            Rg_Solicitud reg = listaActividades.get(i);
            String ejecutor = reg.getEjecutor();
            if (!ejecutor.equals("comodin")) {
                int idnodo = reg.getIdSolicitud();
                int idSolicitud = Integer.parseInt(leerPropiedadporActividad(idnodo, Constantes.Atributo.idSolicitudActividad));
                Solicitudaperturapostgrado solicitud = logica.getLogAperturaPostgrado().leerSolicitudApertura(idSolicitud);
                reg.setFechamodificacion(solicitud.getFechamodificacion());
                reg.setNombreinstanciaproceso(nombreInstancia);
                String accion = "";
                if (Constantes.SolicitarAperturaPostgrado.revisarSolicitud.equals(reg.getActividad())) {
                    accion = this.leerPropiedadporActividad(reg.getIdSolicitud(), Constantes.Atributo.decisionRevision);
                    accion = Constantes.Atributo.decisionRevision + ": " + accion;
                }
                if (Constantes.SolicitarAperturaPostgrado.volveraSolicitar.equals(reg.getActividad())) {
                    accion = this.leerPropiedadporActividad(reg.getIdSolicitud(), Constantes.Atributo.decisionVolverASolicitar);
                    accion = Constantes.Atributo.decisionVolverASolicitar + ": " + accion;
                }
                if (Constantes.SolicitarAperturaPostgrado.revisarInformes.equals(reg.getActividad())) {
                    accion = this.leerPropiedadporActividad(reg.getIdSolicitud(), Constantes.Atributo.decisionEvaluacion);
                    accion = Constantes.Atributo.decisionEvaluacion + ": " + accion;
                }
                if ((solicitud.getFkIdEvaluador1() != 0) && Constantes.SolicitarAperturaPostgrado.emitirInformeEvaluador1.equals(reg.getActividad())) {
                    accion = "Informe: " + this.leerPropiedadporActividad(reg.getIdSolicitud(), Constantes.Atributo.informe1);
                }
                if ((solicitud.getFkIdEvaluador2() != 0) && Constantes.SolicitarAperturaPostgrado.emitirInformeEvaluador2.equals(reg.getActividad())) {
                    accion = "Informe: " + this.leerPropiedadporActividad(reg.getIdSolicitud(), Constantes.Atributo.informe2);
                }
                if ((solicitud.getFkIdEvaluador3() != 0) && Constantes.SolicitarAperturaPostgrado.emitirInformeEvaluador3.equals(reg.getActividad())) {
                    accion = "informe: " + this.leerPropiedadporActividad(reg.getIdSolicitud(), Constantes.Atributo.informe3);
                }
                reg.setAccion(accion);
                //truco: pongo el id del nodo en estado porque lo voy a necesitar para enviarlo en el url de la actividad 
                reg.setEstado(idnodo + "");
                reg.setIdSolicitud(idSolicitud);
                reg.setModelo(Constantes.Modelo.modelo_SolicitarAperturaPostgrado);
                reg.setEjecutor(logica.leerPersonaPorUsuario(ejecutor).toString());
            } else {
                listaActividades.remove(i);
                i--;
            }
        }

        return listaActividades;
    }

    public Vector<Rg_Solicitud> leerProcesosEnCursoPorUsuario(String usuario) throws SQLException {
        Vector<Rg_Solicitud> listaInstancias = new Vector<Rg_Solicitud>();
        Connection con = null;
        try {
            con = conexionDBHistorial.openConexion();
            consultasHistorial.setConexion(con);
            listaInstancias = consultasHistorial.leerProcesosEncursoPorUsuario(usuario);

        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return listaInstancias;
    }

    public Vector<Rg_Solicitud> leerProcesosEnCursoPorRol(String rol) throws SQLException {
        Vector<Rg_Solicitud> listaInstancias = new Vector<Rg_Solicitud>();
        Connection con = null;
        try {
            con = conexionDBHistorial.openConexion();
            consultasHistorial.setConexion(con);
            listaInstancias = consultasHistorial.leerProcesosEncursoPorRol(rol);

        } finally {
            if (con != null) {
                con.close();
            }
        }
        return listaInstancias;
    }

    public Vector<Rg_Solicitud> leerProcesosHistorialPorUsuario(String usuario) throws SQLException {
        Vector<Rg_Solicitud> listaInstancias = new Vector<Rg_Solicitud>();
        Connection con = null;
        try {
            con = conexionDBHistorial.openConexion();
            consultasHistorial.setConexion(con);
            listaInstancias = consultasHistorial.leerProcesosHistorialPorUsuario(usuario);

        } finally {
            try {
                if (con != null) {
                    con.close();
                }
            } catch (SQLException ex) {
                Logger.getLogger(Logica.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        return listaInstancias;
    }

    public String desagruparPalabra(String valor) {
        Pattern p = Pattern.compile("^[A-Z]*[a-z]");
        Matcher m = p.matcher(valor);
        boolean b = false;
        int[] indiceCoincidencias = new int[6];
        int indice = 0;
        while (b = m.find()) {
            indiceCoincidencias[indice] = m.start();
            System.out.println("las coincidencias " + indiceCoincidencias[indice]);
            indice++;
        }
        String[] palabras = valor.split("^[A-Z]*[a-z]");
        String palabraFinal = "";
        for (int i = 0; i < palabras.length; i++) {
//            palabraFinal += valor.substring(indiceCoincidencias[i], indiceCoincidencias[i]) + palabras[i] + " ";
            System.out.println("las palabras " + palabras[i]);
            palabraFinal += palabras[i] + " ";
        }
        System.out.println("paldskdlgfd " + palabraFinal);
        return palabraFinal;
    }
}
